package com.sun.module_base.network.error

import androidx.core.net.ParseException
import com.google.gson.JsonParseException
import com.google.gson.stream.MalformedJsonException
import com.sun.module_network.ApiException
import com.sun.module_network.Error
import com.sun.module_network.createException
import kotlinx.coroutines.CancellationException
import org.json.JSONException
import retrofit2.HttpException
import java.net.ConnectException
import java.net.SocketTimeoutException
import java.net.UnknownHostException
import java.util.concurrent.TimeoutException
import javax.net.ssl.SSLException

/**
 *@author:sunc
 *@time :2025/7/18 16:53
 *@desc: 错误统一处理
 *
 * // 创建基本异常
 * val exception = Error.NETWORK_ERROR.createException()
 *
 * // 创建带自定义消息的异常
 * val customException = Error.TIMEOUT.createException(message = "请求超时，请检查网络")
 *
 * // 创建带上下文的异常
 * val contextException = Error.PARSE_ERROR.createException(
 *     context = mapOf("response" to responseData)
 * )
 *
 * // 创建业务异常
 * val businessException = Error.BUSINESS_ERROR.createBusinessException(
 *     message = "用户余额不足"
 * )
 *
 * // 创建系统异常
 * val systemException = Error.UNKNOWN.createSystemException(
 *     cause = originalException
 * )
 */
object ExceptionHandle {

    /**
     * 异常处理函数，将不同类型的异常转换为统一的ApiException
     * @param e 捕获到的异常对象，可能为null
     * @return 返回转换后的ApiException对象
     */
    fun handlerException(e: Throwable?): ApiException {
        // 如果异常对象为null，则返回一个默认的ApiException
        if (e == null) return Error.UNKNOWN.createException()

        // 如果已经是ApiException，直接返回
        if (e is ApiException) return e

        // 根据异常类型进行分类处理
        return when (e) {
            // 处理HTTP相关异常
            is HttpException -> handleHttpException(e)

            // 处理JSON解析相关异常
            is JsonParseException,  // JSON解析异常
            is ParseException,       // 解析异常
            is MalformedJsonException, // 格式错误的JSON异常
            is JSONException -> Error.PARSE_ERROR.createException(e)

            // 处理网络连接相关异常
            is ConnectException -> Error.NETWORK_ERROR.createException(e)
            // 处理SSL相关异常
            is SSLException -> Error.SSL_ERROR.createException(e)  // SSL异常
            // 处理超时相关异常
            is SocketTimeoutException , is TimeoutException-> Error.TIMEOUT.createException(e)
            // 处理未知主机异常
            is UnknownHostException -> Error.UNKNOWN_HOST.createException(e)  // 未知主机异常

            // 处理HTTP取消请求异常
            is CancellationException -> Error.HTTP_CANCEL.createException(e) // 取消请求异常
            // 处理其他未知异常
            else -> handleUnknownException(e)


        }
    }

    /**
     * 处理HTTP异常
     * @param httpException HTTP异常对象
     * @return 对应的ApiException
     */
    private fun handleHttpException(httpException: HttpException): ApiException {
        // 根据HTTP状态码创建对应的ApiException
        return when (httpException.code()) {
            // 服务器内部错误
            500 -> Error.HTTP_ERROR_500.createException(httpException)
            // 资源未找到
            404 -> Error.HTTP_ERROR_404.createException(httpException)
            // 禁止访问
            403 -> Error.HTTP_ERROR_403.createException(httpException)
            // 需要付费
            402 -> Error.HTTP_ERROR_402.createException(httpException)
            // 临时重定向
            307 -> Error.HTTP_ERROR_307.createException(httpException)
            // 未授权访问
            401 -> Error.HTTP_ERROR_401.createException(httpException)
            // 其他未指定的HTTP错误
            else -> Error.HTTP_ERROR.createException(httpException)
        }
    }

    /**
     * 处理未知异常
     */
    private fun handleUnknownException(e: Throwable): ApiException {
        return e.message?.let {
            Error.UNKNOWN_WITH_MESSAGE.createException(e, message = it)
        } ?: Error.UNKNOWN.createException(e)
    }
}